const express = require('express');
const router = express.Router();
const WorkOrder = require('../models/WorkOrder');
const User = require('../models/User'); // 新增：引入用户模型
const mongoose = require('mongoose');

// 1. 用户创建工单（初始状态：待处理）
router.post('/', async (req, res) => {
  try {
    const { customer_name, customer_phone, customer_address, customer_id, user_claim } = req.body;
    
    // 校验必填参数
    if (!customer_name || !customer_phone || !customer_address || !customer_id || !user_claim) {
      return res.status(400).json({ code: 400, message: '客户姓名、电话、地址、ID和用户诉求为必填字段' });
    }

    const newOrder = new WorkOrder({
      customer_name,
      customer_phone,
      customer_address,
      customer_id,
      user_claim,
      status: '待处理' // 默认初始状态
    });

    // 新增：查询客服姓名
    const customer = await User.findById(customer_id);
    const customername = customer?.name || '未知用户'; // 若用户不存在，显示"未知用户"

    // 添加客服处理事件记录（替换ID为姓名）
    const customerTime = new Date().toLocaleString();
    const customerEvent = `【${customerTime}】客服（${customername}）：创建工单（状态变更为待处理 ）`; // 修改此处
    newOrder.events.push(customerEvent);
    
    await newOrder.save();

    res.status(201).json({ code: 201, message: '工单创建成功', data: newOrder });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 2. 客服处理工单（待处理→已完成/待分配站点）
router.put('/:id/staff', async (req, res) => {
  try {
    const { id } = req.params;
    const { staff_judgment, targetStatus, staff_id } = req.body;

    // 校验工单ID有效性
    if (!mongoose.Types.ObjectId.isValid(id)) {
      return res.status(400).json({ code: 400, message: '无效的工单ID' });
    }

    const order = await WorkOrder.findById(id);
    if (!order) return res.status(404).json({ code: 404, message: '工单不存在' });
    if (order.status !== '待处理') {
      return res.status(400).json({ code: 400, message: '仅允许处理状态为"待处理"的工单' });
    }

    // 校验目标状态合法性
    if (!['已完成', '待分配站点'].includes(targetStatus)) {
      return res.status(400).json({ code: 400, message: '目标状态仅允许"已完成"或"待分配站点"' });
    }

    // 更新状态和客服判断
    order.status = targetStatus;
    if (staff_judgment) order.staff_judgment = staff_judgment;

    // 新增：查询客服姓名
    const staff = await User.findById(staff_id);
    const staffName = staff?.name || '未知用户'; // 若用户不存在，显示"未知用户"

    // 添加客服处理事件记录（替换ID为姓名）
    const staffTime = new Date().toLocaleString();
    const staffEvent = `【${staffTime}】客服（${staffName}）：处理工单（状态变更为${targetStatus}）`; // 修改此处
    order.events.push(staffEvent);
    await order.save();

    res.json({ code: 200, message: '客服处理成功', data: order });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 3. 管理员分派维修站点（待分配站点→待分派维修员）
router.put('/:id/admin', async (req, res) => {
  try {
    const { id } = req.params;
    const { station_id } = req.body; // 可选：指定站点ID

    if (!mongoose.Types.ObjectId.isValid(id)) {
      return res.status(400).json({ code: 400, message: '无效的工单ID' });
    }

    const order = await WorkOrder.findById(id);
    if (!order) return res.status(404).json({ code: 404, message: '工单不存在' });
    if (order.status !== '待分配站点') {
      return res.status(400).json({ code: 400, message: '仅允许处理状态为"待分配站点"的工单' });
    }

    order.status = '待分派维修员';
    if (station_id) order.station_id = station_id; // 关联站点ID
    const station = await User.findById(station_id);
    const stationname = station?.name || '未知用户';
    // 添加管理员分派事件记录（替换ID为姓名）
    const adminTime = new Date().toLocaleString();
    const adminEvent = `【${adminTime}】管理员：分派维修站点(${stationname})（状态变更为待分派维修员）`;
    order.events.push(adminEvent);
    
    await order.save();

    res.json({ code: 200, message: '管理员分派站点成功', data: order });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 4. 站点分派维修员（待分派维修员→待预约）
router.put('/:id/station', async (req, res) => {
  try {
    const { id } = req.params;
    const { repairman_id } = req.body; // 必传：指定维修员ID

    if (!mongoose.Types.ObjectId.isValid(id)) {
      return res.status(400).json({ code: 400, message: '无效的工单ID' });
    }
    if (!repairman_id) {
      return res.status(400).json({ code: 400, message: '维修员ID为必填字段' });
    }

    const order = await WorkOrder.findById(id);
    if (!order) return res.status(404).json({ code: 404, message: '工单不存在' });
    if (order.status !== '待分派维修员') {
      return res.status(400).json({ code: 400, message: '仅允许处理状态为"待分派维修员"的工单' });
    }

    order.status = '待预约';
    order.repairman_id = repairman_id; // 关联维修员ID

    const repair = await User.findById(repairman_id);
    const repairname = repair?.name || '未知用户';
    // 添加管理员分派事件记录（替换ID为姓名）
    const stationTime = new Date().toLocaleString();
    const stationEvent = `【${stationTime}】站点分派维修员(${repairname})（状态变更为待预约时间）`;
    order.events.push(stationEvent);


    await order.save();

    res.json({ code: 200, message: '站点分派维修员成功', data: order });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 5. 用户选择预约时间（待预约→待上门服务）
router.put('/:id/user', async (req, res) => {
  try {
    const { id } = req.params;
    const { appointment_time, customer_id } = req.body; // 需前端传递用户ID

    if (!mongoose.Types.ObjectId.isValid(id)) {
      return res.status(400).json({ code: 400, message: '无效的工单ID' });
    }
    if (!appointment_time) {
      return res.status(400).json({ code: 400, message: '预约时间为必填字段' });
    }
    if (new Date(appointment_time).toString() === 'Invalid Date') {
      return res.status(400).json({ code: 400, message: '预约时间格式错误（需ISO格式，如"2024-12-31T14:00:00Z"）' });
    }

    const order = await WorkOrder.findById(id);
    if (!order) return res.status(404).json({ code: 404, message: '工单不存在' });
    if (order.status !== '待预约') {
      return res.status(400).json({ code: 400, message: '仅允许处理状态为"待预约"的工单' });
    }

    order.status = '待上门服务';
    order.appointment_time = appointment_time;

    // 新增：查询用户姓名
    const customer = await User.findById(customer_id);
    const customerName = customer?.name || '未知用户';

    // 添加用户预约事件记录（替换ID为姓名）
    const appointTime = new Date().toLocaleString();
    const appointEvent = `【${appointTime}】用户（${customerName}）：选择预约时间（${appointment_time}）`; // 修改此处
    order.events.push(appointEvent);

    await order.save();

    res.json({ code: 200, message: '用户预约时间设置成功', data: order });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 6. 维修员完成维修（待上门服务→待客服回访）
router.put('/:id/repairman', async (req, res) => {
  try {
    const { id } = req.params;
    const { repair_inspection, repair_result, repairman_id } = req.body; // 需前端传递维修员ID

    if (!mongoose.Types.ObjectId.isValid(id)) {
      return res.status(400).json({ code: 400, message: '无效的工单ID' });
    }
    if (!repair_inspection || !repair_result) {
      return res.status(400).json({ code: 400, message: '检测结果和维修结果为必填字段' });
    }

    const order = await WorkOrder.findById(id);
    if (!order) return res.status(404).json({ code: 404, message: '工单不存在' });
    if (order.status !== '待上门服务') {
      return res.status(400).json({ code: 400, message: '仅允许处理状态为"待上门服务"的工单' });
    }

    order.status = '待客服回访';
    order.repair_inspection = repair_inspection;
    order.repair_result = repair_result;

    // 新增：查询维修员姓名
    const repairman = await User.findById(repairman_id);
    const repairmanName = repairman?.name || '未知用户';

    // 添加维修完成事件记录（替换ID为姓名）
    const repairTime = new Date().toLocaleString();
    const repairEvent = `【${repairTime}】维修员（${repairmanName}）：完成维修（检测结果：${repair_inspection}，维修结果：${repair_result}）`; // 修改此处
    order.events.push(repairEvent);

    await order.save();
    res.json({ code: 200, message: '维修完成记录成功', data: order });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 7. 客服最终完成（待客服回访→已完成）
router.put('/:id/finish', async (req, res) => {
  console.log(112213123123123123);
  
  try {
    const { id } = req.params;
    const { feedback } = req.body;

    if (!mongoose.Types.ObjectId.isValid(id)) {
      return res.status(400).json({ code: 400, message: '无效的工单ID' });
    }

    const order = await WorkOrder.findById(id);
    console.log(`[工单完成接口] 查询到的工单: ${JSON.stringify(order)}`); // 新增日志
    if (!order) return res.status(404).json({ code: 404, message: '工单不存在' });
    if (order.status !== '待客服回访') {
      return res.status(400).json({ code: 400, message: '仅允许处理状态为"待客服回访"的工单' });
    }

    order.status = '已完成';
    if (feedback) order.feedback = feedback; // 可选：回访反馈

    const adminTime = new Date().toLocaleString();
    const adminEvent = `【${adminTime}】客服完成回访：（${feedback}）（状态变更为"已完成"）`;
    order.events.push(adminEvent);



    await order.save();

    res.json({ code: 200, message: '工单最终完成', data: order });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 8. 获取全部工单列表（带分页和排序）
router.get('/ordersList', async (req, res) => {
  try {
    const { page = 1, limit = 10, sort = '-createdAt' } = req.query;
    
    const orders = await WorkOrder.find()
      .sort(sort)
      .skip((page - 1) * limit)
      .limit(Number(limit))
      .select('-events'); // 排除操作记录字段

    const total = await WorkOrder.countDocuments();
    
    res.json({ 
      code: 200, 
      data: {
        total,
        page: Number(page),
        pages: Math.ceil(total / limit),
        orders
      }
    });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 9. 按状态获取工单列表
router.get('/by-status', async (req, res) => {
  try {
    const { status, customer_id } = req.query;
    console.log(status, customer_id );
    
    const validStatus = ['待处理', '待分配站点', '待分派维修员', '待预约', 
                        '待上门服务', '待客服回访', '已完成'];

    if (!validStatus.includes(status)) {
      return res.status(400).json({ 
        code: 400, 
        message: '状态参数不合法',
        validStatus
      });
    }
    let orders = null
        if (!customer_id) {

       orders = await WorkOrder.find({ status })
       .sort('-createdAt')
       .select('-events');
      }
       else{
        orders = await WorkOrder.find({ status, customer_id })
        .sort('-createdAt')
        .select('-events');
       }


    res.json({ code: 200, data: orders });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 10. 根据工单ID查询详细信息（新增接口）
router.get('/:id', async (req, res) => {
  try {
    const { id } = req.params;

    // 校验工单ID格式
    if (!mongoose.Types.ObjectId.isValid(id)) {
      return res.status(400).json({ code: 400, message: '无效的工单ID' });
    }

    // 查询工单（包含完整事件记录）
    const order = await WorkOrder.findById(id);
    if (!order) return res.status(404).json({ code: 404, message: '工单不存在' });

    res.json({ code: 200, message: '工单信息查询成功', data: order });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

// 11. 根据用户ID查询订单列表（新增接口）
router.get('/by-customer/:customerId', async (req, res) => {
  try {
    const { customerId } = req.params;

    // 校验用户ID格式（MongoDB ObjectId）
    if (!mongoose.Types.ObjectId.isValid(customerId)) {
      return res.status(400).json({ code: 400, message: '无效的用户ID' });
    }

    // 查询该用户的所有工单（排除事件记录，保持与/ordersList一致）
    const orders = await WorkOrder.find({ customer_id: customerId })
      .sort('-createdAt') // 默认按创建时间倒序排列
      .select('-events'); // 排除操作记录字段

    res.json({ code: 200, message: '用户订单列表查询成功', data: orders });
  } catch (err) {
    res.status(500).json({ code: 500, message: '服务器错误', error: err.message });
  }
});

module.exports = router;